package writtenTraining.day18;

import java.util.*;

/**
 * day18: （1）模拟：NC101 压缩字符串(一)
 */

public class Solution {
    

    public String compressString (String param) {
        // 特殊情况判断
        if(param == null || param.length() == 0) {
            return "";
        }

        char ch = param.charAt(0);
        int len = param.length();
        int count = 0;
        String ret = "";
        for(int i = 0; i < len; i++) {
            if(param.charAt(i) == ch) {
                count++;
            } else {
                // 加入结果
                ret += ch;
                if(count > 1)
                ret += count;

                // 更新个数和校验字符
                count = 1;
                ch = param.charAt(i);
            }
        }

        // 最后加入末尾字符
        ret += ch;
        if(count > 1)
        ret += count;
        return ret;
    }
}


/**
 * day18:(2)排序+模拟：chika和蜜柑
 */


class Fruit {
    public Long sour;
    public Long sweet;
}

 class Main1 {
    public static void main(String[] args) {
//         排序 + 模拟

        // 输入
        Scanner in = new Scanner(System.in);
        int n = in.nextInt(), k = in.nextInt();
        Fruit[] fruits = new Fruit[n];

        for(int i = 0; i < n; i++) {
            fruits[i] = new Fruit();
            fruits[i].sour = in.nextLong();
        }

        for(Fruit fruit : fruits) {
            fruit.sweet = in.nextLong();
        }


//         排序
        Arrays.sort(fruits,(a,b)->{
            if(a.sweet.equals(b.sweet)) {
                return a.sour.compareTo(b.sour);
            }

            return b.sweet.compareTo(a.sweet);
        });


//         输出结果
        long sourSum = 0L,  sweetSum = 0L;
        for(int i = 0; i < k ; i++) {
            sourSum += fruits[i].sour;
            sweetSum += fruits[i].sweet;
        }

        System.out.println(sourSum + " " + sweetSum);

    }

}


/**
 * day18:(3)：动态规划+01背包问题：NC145 01背包
 */



class Solution2 {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 计算01背包问题的结果
     * @param V int整型 背包的体积
     * @param n int整型 物品的个数
     * @param vw int整型二维数组 第一维度为n,第二维度为2的二维数组,vw[i][0],vw[i][1]分别描述i+1个物品的vi,wi
     * @return int整型
     */
    public int knapsack (int V, int n, int[][] vw) {
        // 动态规划 + 01背包
        // 创建 dp
        int[][] dp = new int[n+1][V+1];

        // 初始化
        // 填表
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= V; j++) {
                // 先继承上一个物品的体积
                dp[i][j] = dp[i-1][j];
                // 如果还能装下
                if(j >= vw[i-1][0] ) {
                    // 看前面物品的剩余体积看是否还能装

                    dp[i][j] = Math.max(dp[i][j]
                            , dp[i - 1][j - vw[i-1][0]] + vw[i-1][1]);
                }
            }
        }


        // 确定返回值
        return dp[n][V];
    }
}

/**
 * day18:(3)：动态规划+01背包问题+滚动数组空间优化：NC145 01背包
 */

class Solution3 {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 计算01背包问题的结果
     * @param V int整型 背包的体积
     * @param n int整型 物品的个数
     * @param vw int整型二维数组 第一维度为n,第二维度为2的二维数组,vw[i][0],vw[i][1]分别描述i+1个物品的vi,wi
     * @return int整型
     */
    public int knapsack (int V, int n, int[][] vw) {
        // 动态规划 + 01背包
        // 创建 dp
        int[] dp = new int[V+1];

        // 初始化
        // 填表
        for(int i = 1; i <= n; i++) {
            for(int j = V; j >= vw[i-1][0]; j--) {
                // 先继承上一个物品的体积
                // 如果还能装下
                // 看前面物品的剩余体积看是否还能装
                dp[j] = Math.max(dp[j]
                        , dp[j - vw[i-1][0]] + vw[i-1][1]);
            }
        }


        // 确定返回值
        return dp[V];
    }
}